package top.humbleyuan.test.Huawei;

import java.util.*;

public class HuaWei3 {

    static class Function {
        int id; //函数编号
        int stack; //栈大小
        List<Integer> callee; //被调函数

        static Function parse(String[] input) {
            Function function = new Function();
            function.id = Integer.parseInt(input[0]);
            function.stack = Integer.parseInt(input[1]);
            function.callee = new ArrayList<>();
            for (int i = 2; i < input.length; i++) {
                function.callee.add(Integer.parseInt(input[i]));
            }
            return function;
        }
    }

    public static int solve(Map<Integer, Function> functions) {
        int max = Integer.MIN_VALUE;
        for (Map.Entry<Integer, Function> entry : functions.entrySet()) {
            Function function = entry.getValue();
            List<Integer> cost = new ArrayList<>();     // 每个dfs耗费，最后选出最大的

            LinkedList<Integer> trace = new LinkedList<>();     // 调用链

            dfs(functions, trace, function, 0, cost);

            // 存在递归则计算环的大小
//            if (!dfs(functions, trace, function, 0, cost)) {
//                return -1; //存在递归
//            }

            // 每个函数进行所有的调用方式的花费中选最大值和当前最大值比
            max = Math.max(max, cost.stream().max(Comparator.comparingInt(a -> a)).orElse(Integer.MIN_VALUE));
        }
        return max;
    }

    //返回是否存在递归
    public static boolean dfs(Map<Integer, Function> functions, //函数
                              LinkedList<Integer> trace, //调用链
                              Function current, //当前函数
                              int stack, //栈大小
                              List<Integer> cost //所有的栈大小
    ) {
//        //递归了
//        if (trace.contains(current.id)) {
//            return false;
//        }
        List<Integer> callee = current.callee;  // 当前函数所有要调用的函数

        if(trace.contains(current.id)) {
            cost.add(stack + current.stack);
            return false;
        }

        //最后一个调用或者首次递归了返回当前值,类似剪枝
        if (callee.isEmpty() ) {
            cost.add(stack + current.stack);
        } else {
            trace.addLast(current.id);
            for (int func : callee) {

                // 递归剪枝
                if (!dfs(functions, trace, functions.get(func), stack + current.stack, cost)) {
                    return false;
                }
            }
            trace.removeLast();
        }
        return true;
    }


    /**
     * 5 2 3 1 0 0
     * 1 20 2 3
     * 2 30 3 4 5
     * 3 50 4
     * 4 60
     * 5 80
     * @param args
     */
    public static void main(String[] args) {
        try (Scanner in = new Scanner(System.in)) {
            int n = in.nextInt();
            int[] invokes = new int[n];     // invokes存第一行
            for (int i = 0; i < n; i++) {
                invokes[i] = in.nextInt();
            }
            in.nextLine();
            Map<Integer, Function> functions = new HashMap<>();
            for (int i = 0; i < n; i++) {
                String line = in.nextLine();
                String[] input = line.split(" ");
                int len = input.length;
                // 非法输入判断
                if (len != invokes[i] + 2) {
                    System.out.println("NA");
                    return;
                }

                // 封装每个方法
                Function function = Function.parse(input);


//                if (function.callee.contains(function.id)) {
//                    System.out.println("R");
//                    return;
//                }

                functions.put(function.id, function);
            }
            int solve = solve(functions);

            // 有递归即有环时停止，得当前值
            System.out.println(solve == -1 ? "R" : solve);
        }
    }
}